package com.java.eight.lambda;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @version v1.0
 * @description: 苹果过滤器
 * @author: xiaoliang.liu
 * @date: 2018/7/8 11:22
 */
public class FilterApple {

    /** 内部接口： 使用策略模式应对多变的筛选条件 */
    /**
    * @description: 苹果策略接口
    * @author: xiaoliang.liu
    * @date: 2018/7/8 12:11
    * @version v1.0
    */
    @FunctionalInterface
    public interface AppleFilter {
        /**
         * 过滤策略
         * @param apple 苹果
         * @return boolean
         */
        boolean filter(Apple apple);

        /** 可以有default方法 */
        default void print() {
            System.out.println("default print");
        }

        /** 有@FunctionalInterface注解 不能有两个方法 */
//        boolean isTrue();
    }

    /** 内部类： 使用策略模式应对多变的筛选条件 */
    /**
    * @description: 查找绿色和重量在20以上的苹果
    * @author: xiaoliang.liu
    * @date: 2018/7/8 12:11
    * @version v1.0
    */
    public static class GreenAnd20WeightAppleFilter implements AppleFilter {

        @Override
        public boolean filter(Apple apple) {
            return "green".equals(apple.getColor()) && apple.getWeight() >= 20;
        }
    }






    /**
     * 根据(策略)条件查找苹果集合，(策略模式)
     * @param apples 苹果集合
     * @param appleFilter 苹果策略
     * @return list
     */
    private static List<Apple> findApplesByCondition(List<Apple> apples, AppleFilter appleFilter) {
        ArrayList<Apple> list = new ArrayList<>();
        for (Apple apple : apples) {
            if (apple != null) {
                if (appleFilter.filter(apple)) {
                    list.add(apple);
                }
            }
        }
        return list;
    }

    /**
     * 找到绿色的苹果
     *
     * @param apples 苹果集合
     * @return 绿色苹果集合
     */
    private static List<Apple> findGreenApple(List<Apple> apples) {

        ArrayList<Apple> list = new ArrayList<>();

        for (Apple apple : apples) {
            if (apple != null) {
                if ("green".equals(apple.getColor())) {
                    list.add(apple);
                }
            }
        }
        return list;
    }

    /**
     * 根据颜色查找苹果集合
     *
     * @param apples 苹果集合
     * @param color  颜色
     * @return list
     */
    private static List<Apple> findAppleByColor(List<Apple> apples, String color) {
        if (color == null) {
            return null;
        }

        ArrayList<Apple> list = new ArrayList<>();

        for (Apple apple : apples) {
            if (apple != null) {
                if (color.equals(apple.getColor())) {
                    list.add(apple);
                }
            }
        }
        return list;
    }


    /**
     * 主方法
     */
    public static void main(String[] args) throws InterruptedException {
        List<Apple> apples = Arrays.asList(new Apple("green", 25L), new Apple("green", 20L), new Apple("green", 10L), new Apple("red", 15L));
        // 找绿色的苹果
        List<Apple> greenApples = findGreenApple(apples);

        // 根据传入的颜色查找苹果
        List<Apple> redApples = findAppleByColor(apples, "red");
        List<Apple> redApples1 = findAppleByColor(apples, "green");

        // 使用策略模式适应多种条件的查找（在外面创建一个策略类继承策略接口）
        List<Apple> applesByCondition = findApplesByCondition(apples, new GreenAnd20WeightAppleFilter());

        // 使用策略+匿名内部类(不用在外面创建一个策略类继承策略接口)
        List<Apple> applesByCondition1 = findApplesByCondition(apples, new AppleFilter() {
            @Override
            public boolean filter(Apple apple) {
                return "green".equals(apple.getColor()) && apple.getWeight() >= 25;
            }
        });

        // 使用策略+lambda表达式(不用在外面创建一个策略类继承策略接口)
        List<Apple> applesByCondition2 = findApplesByCondition(apples, apple -> "green".equals(apple.getColor()) && (apple.getWeight() >= 0 && apple.getWeight() < 20));


//        System.out.println("绿色：" + greenApples);
//        System.out.println("红色(根据颜色)：" + redApples);
//        System.out.println("绿色(策略)：" + applesByCondition);
//        System.out.println("绿色(策略+匿名内部类)：" + applesByCondition1);
//        System.out.println("绿色(策略+lambda表达式)：" + applesByCondition2);



        // 使用匿名内部类的方法创建线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程名1：" + Thread.currentThread().getName());
            }
        }).start();
        System.out.println("主线程名："+Thread.currentThread().getName());

        // 使用lambda创建线程
        new Thread(() -> System.out.println("当前线程名2：" + Thread.currentThread().getName())).start();



        // 阻断main线程
        Thread.currentThread().join();


    }
}
